package utils;

import entity.item;
import entity.taskInfo;
import entity.worker;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DataFilter {

    // 定义有效的制造单元名称
    private static final List<String> VALID_WORKER_GROUP_NAMES = Arrays.asList(
//            "钣金一工段", "钣金二工段", "钣金三工段", "钣金四工段",
//            "蒙皮工段", "型材工段", "钳工工段"
            "钣金一工段"
    );

    // 更新后的有效工段名称列表
    private static final List<String> VALID_WORKCENTER_NAMES = Arrays.asList(
//            "23_钣金一工段", "23_钣金二工段", "23_钣金三工段", "23_钣金四工段",
//            "23_蒙皮工段", "23_型材工段", "23_钳工工段"
            "23_钣金一工段"
    );

    // 已下发状态的常量
    private static final String STATUS_ISSUED = "已下发";

    /**
     * 过滤工人数据
     * @param workers 工人列表
     * @return 过滤后的工人列表
     */
    public List<worker> filterWorkers(List<worker> workers) {
        List<worker> validWorkers = new ArrayList<>();

        if (workers == null || workers.isEmpty()) {
            return validWorkers;
        }

        for (worker worker : workers) {
            if (isValidWorker(worker)) {
                validWorkers.add(worker);
            }
        }

        return validWorkers;
    }

    /**
     * 过滤物料数据
     * @param items 物料列表
     * @return 过滤后的物料列表
     */
    public List<item> filterItems(List<item> items) {
        List<item> validItems = new ArrayList<>();

        if (items == null || items.isEmpty()) {
            return validItems;
        }

        for (item item : items) {
            if (isValidItem(item)) {
                validItems.add(item);
            }
        }

        return validItems;
    }

    /**
     * 过滤任务信息
     * @param taskInfos 任务信息列表
     * @param items 已过滤的有效物料列表
     * @return 过滤后的任务信息列表
     */
    public List<taskInfo> filterTaskInfos(List<taskInfo> taskInfos, List<item> items) {
        List<taskInfo> validTaskInfos = new ArrayList<>();

        if (taskInfos == null || taskInfos.isEmpty()) {
            return validTaskInfos;
        }

        // 构建itemID到Item的映射，用于快速查找
        Map<String, item> itemMap = new HashMap<>();
        for (item item : items) {
            itemMap.put(item.getItemId(), item);
        }

        for (taskInfo taskInfo : taskInfos) {
            if (isValidTaskInfo(taskInfo, itemMap)) {
                validTaskInfos.add(taskInfo);
            }
        }

        return validTaskInfos;
    }

    /**
     * 验证工人数据是否有效
     */
    private boolean isValidWorker(worker worker) {
        if (worker == null) {
            return false;
        }

        // 验证制造单元名称
        if (!VALID_WORKER_GROUP_NAMES.contains(worker.getMdsWorkerGroupName())) {
            return false;
        }

        // 验证能力系数
        if (!isValidCoefficient(worker.getCapacityCodfficient())) {
            return false;
        }

        // 验证效率系数
        if (!isValidCoefficient(worker.getEfficiencyCodfficient())) {
            return false;
        }

        return true;
    }

    /**
     * 验证物料数据是否有效
     */
    private boolean isValidItem(item item) {
        if (item == null) {
            return false;
        }

        // 检查制造周期数据是否合法
        if(!isValidCoefficient(item.getMakeCycle())){
            return false;
        }

        // 检测难度系数数据是否合法
        if(!isValidCoefficient(item.getItemDifficulty())){
            return false;
        }

        // 验证工段名称
        return VALID_WORKCENTER_NAMES.contains(item.getWorkcenterName());
    }

    /**
     * 验证任务信息是否有效
     */
    private boolean isValidTaskInfo(taskInfo taskInfo, Map<String, item> itemMap) {
        if (taskInfo == null) {
            return false;
        }

        // 检查下发状态
        if (!STATUS_ISSUED.equals(taskInfo.getSuspendOrIssuedStatus())) {
            return false;
        }

        // 检查关联的Item是否有效
        String itemId = taskInfo.getItemID();
        return itemMap.containsKey(itemId); // 只要在有效的Item映射中存在，说明该Item已经通过工段名称的验证
    }

    /**
     * 验证系数是否有效
     */
    private boolean isValidCoefficient(Double coefficient) {
        if (coefficient == null) {
            return false;
        }

        //留下大于零的合法数字
        return !Double.isNaN(coefficient) && !Double.isInfinite(coefficient) && coefficient > 0;
    }
}